home *** CD-ROM | disk | FTP | other *** search
/ Aminet 23 / Aminet 23 (1998)(GTI - Schatztruhe)[!][Feb 1998].iso / Aminet / misc / emu / amiSPIMsrc.lha / mem.h < prev    next >
C/C++ Source or Header  |  1994-01-17  |  9KB  |  284 lines
  1. /* SPIM S20 MIPS simulator.
  2.    Macros for accessing memory.
  3.    Copyright (C) 1990-1994 by James Larus (larus@cs.wisc.edu).
  4.    ALL RIGHTS RESERVED.
  5.  
  6.    SPIM is distributed under the following conditions:
  7.  
  8.      You may make copies of SPIM for your own use and modify those copies.
  9.  
  10.      All copies of SPIM must retain my name and copyright notice.
  11.  
  12.      You may not sell SPIM or distributed SPIM in conjunction with a
  13.      commerical product or service without the expressed written consent of
  14.      James Larus.
  15.  
  16.    THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  17.    IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  18.    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  19.    PURPOSE. */
  20.  
  21.  
  22. /*   $Header: /home/primost/larus/Software/SPIM/RCS/mem.h,v 3.16 1994/01/18 03:21:45 larus Exp larus $
  23. */
  24.  
  25.  
  26. /* A note on directions:  "Bottom" of memory is the direction of
  27.    decreasing addresses.  "Top" is the direction of increasing addresses.*/
  28.  
  29.  
  30. /* Type of contents of a memory word. */
  31.  
  32. typedef long mem_word;
  33.  
  34.  
  35. /* The text segment and boundaries. */
  36.  
  37. extern instruction **text_seg;
  38.  
  39. extern int text_modified;    /* Non-zero means text segment was written */
  40.  
  41. #define TEXT_BOT ((mem_addr) 0x400000)
  42.  
  43. extern mem_addr text_top;
  44.  
  45.  
  46. /* Amount to grow text segment when we run out of space for instructions. */
  47.  
  48. #define TEXT_CHUNK_SIZE    4096
  49.  
  50.  
  51. /* The data segment and boundaries. */
  52.  
  53. extern mem_word *data_seg;
  54.  
  55. extern int data_modified;    /* Non-zero means a data segment was written */
  56.  
  57. extern short *data_seg_h;    /* Points to same vector as DATA_SEG */
  58.  
  59. #define BYTE_TYPE signed char
  60.  
  61. /* Non-ANSI C compilers do not like signed chars.  You can change it to
  62.    'char' if the compiler will treat chars as signed values... */
  63.  
  64. #if ((defined (sun) || defined (hpux)) && !defined(__STDC__))
  65. /* Sun and HP cc compilers: */
  66. #undef BYTE_TYPE
  67. #define BYTE_TYPE char
  68. #endif
  69.  
  70. extern BYTE_TYPE *data_seg_b;    /* Ditto */
  71.  
  72. #define DATA_BOT ((mem_addr) 0x10000000)
  73.  
  74. extern mem_addr data_top;
  75.  
  76. extern mem_addr gp_midpoint;    /* Middle of $gp area */
  77.  
  78.  
  79. /* The stack segment and boundaries. */
  80.  
  81. extern mem_word *stack_seg;
  82.  
  83. extern short *stack_seg_h;    /* Points to same vector as STACK_SEG */
  84.  
  85. extern BYTE_TYPE *stack_seg_b;    /* Ditto */
  86.  
  87. extern mem_addr stack_bot;
  88.  
  89. /* Exclusive, but include 4K at top of stack. */
  90.  
  91. #define STACK_TOP ((mem_addr) 0x80000000)
  92.  
  93.  
  94. /* The kernel text segment and boundaries. */
  95.  
  96. extern instruction **k_text_seg;
  97.  
  98. #define K_TEXT_BOT ((mem_addr) 0x80000000)
  99.  
  100. extern mem_addr k_text_top;
  101.  
  102.  
  103. /* Kernel data segment and boundaries. */
  104.  
  105. extern mem_word *k_data_seg;
  106.  
  107. extern short *k_data_seg_h;
  108.  
  109. BYTE_TYPE *k_data_seg_b;
  110.  
  111. #define K_DATA_BOT ((mem_addr) 0x90000000)
  112.  
  113. extern mem_addr k_data_top;
  114.  
  115.  
  116. /* Memory-mapped IO area. */
  117.  
  118. #define MM_IO_BOT ((mem_addr) 0xffff0000)
  119.  
  120. #define MM_IO_TOP ((mem_addr) 0xffffffff)
  121.  
  122.  
  123. #define RECV_CTRL_ADDR ((mem_addr) 0xffff0000)
  124.  
  125. #define RECV_READY 0x1
  126. #define RECV_INT_ENABLE 0x2
  127.  
  128. #define RECV_INT_MASK 0x100
  129.  
  130. #define RECV_BUFFER_ADDR ((mem_addr) 0xffff0004)
  131.  
  132.  
  133. #define TRANS_CTRL_ADDR ((mem_addr) 0xffff0008)
  134.  
  135. #define TRANS_READY 0x1
  136. #define TRANS_INT_ENABLE 0x2
  137.  
  138. #define TRANS_INT_MASK 0x200
  139.  
  140. #define TRANS_BUFFER_ADDR ((mem_addr) 0xffff000c)
  141.  
  142.  
  143.  
  144. /* You would think that a compiler could perform CSE on the arguments to
  145.    these macros.  However, complex expressions break some compilers, so
  146.    do the CSE ourselves. */
  147.  
  148. /* Translate from SPIM memory address to physical address */
  149.  
  150. #define MEM_ADDRESS(ADDR)                           \
  151. (((mem_addr) (ADDR) >= TEXT_BOT && (mem_addr) (ADDR) < text_top)       \
  152.  ? (mem_addr) (ADDR) - TEXT_BOT + (mem_addr) text_seg               \
  153.  : (((mem_addr) (ADDR) >= DATA_BOT && (mem_addr) (ADDR) < data_top)       \
  154.     ? (mem_addr) (ADDR) - DATA_BOT + (mem_addr) data_seg           \
  155.     : (((mem_addr) (ADDR) >= stack_bot && (mem_addr) (ADDR) < STACK_TOP)   \
  156.        ? (mem_addr) (ADDR) - stack_bot + (mem_addr) stack_seg           \
  157.        : ((mem_addr) (ADDR) >= K_TEXT_BOT && (mem_addr) (ADDR) < k_text_top)\
  158.        ? (mem_addr) (ADDR) - K_TEXT_BOT + (mem_addr) k_text_seg           \
  159.        : (((mem_addr) (ADDR) >= K_DATA_BOT && (mem_addr) (ADDR) < k_data_top)\
  160.       ? (mem_addr) (ADDR) - K_DATA_BOT + (mem_addr) k_data_seg       \
  161.       : run_error ("Memory address out of bounds\n")))))
  162.  
  163.  
  164. #define READ_MEM_INST(LOC, ADDR)                       \
  165. {register mem_addr _addr_ = (mem_addr) (ADDR);                   \
  166.    if (_addr_ >= TEXT_BOT && _addr_ < text_top && !(_addr_ & 0x3))       \
  167.      LOC = text_seg [(_addr_ - TEXT_BOT) >> 2];                   \
  168.    else if (_addr_ >= K_TEXT_BOT && _addr_ < k_text_top && !(_addr_ & 0x3))\
  169.      LOC = k_text_seg [(_addr_ - K_TEXT_BOT) >> 2];               \
  170.    else LOC = bad_text_read (_addr_);}
  171.  
  172.  
  173. #define READ_MEM_BYTE(LOC, ADDR)                       \
  174. {register mem_addr _addr_ = (mem_addr) (ADDR);                   \
  175.    if (_addr_ >= DATA_BOT && _addr_ < data_top)                   \
  176.     LOC = data_seg_b [_addr_ - DATA_BOT];                   \
  177.    else if (_addr_ >= stack_bot && _addr_ < STACK_TOP)               \
  178.      LOC = stack_seg_b [_addr_ - stack_bot];                   \
  179.    else if (_addr_ >= K_DATA_BOT && _addr_ < k_data_top)           \
  180.     LOC = k_data_seg_b [_addr_ - K_DATA_BOT];                   \
  181.    else                                       \
  182.      LOC = bad_mem_read (_addr_, 0, (mem_word *)&LOC);}
  183.  
  184.  
  185. #define READ_MEM_HALF(LOC, ADDR)                       \
  186. {register mem_addr _addr_ = (mem_addr) (ADDR);                   \
  187.    if (_addr_ >= DATA_BOT && _addr_ < data_top && !(_addr_ & 0x1))       \
  188.      LOC = data_seg_h [(_addr_ - DATA_BOT) >> 1];               \
  189.   else if (_addr_ >= stack_bot && _addr_ < STACK_TOP && !(_addr_ & 0x1))   \
  190.     LOC = stack_seg_h [(_addr_ - stack_bot) >> 1];               \
  191.    else if (_addr_ >= K_DATA_BOT && _addr_ < k_data_top && !(_addr_ & 0x1))\
  192.      LOC = k_data_seg_h [(_addr_ - K_DATA_BOT) >> 1];               \
  193.   else                                       \
  194.     LOC = bad_mem_read (_addr_, 0x1, (mem_word *)&LOC);}
  195.  
  196.  
  197. #define READ_MEM_WORD(LOC, ADDR)                       \
  198. {register mem_addr _addr_ = (mem_addr) (ADDR);                   \
  199.    if (_addr_ >= DATA_BOT && _addr_ < data_top && !(_addr_ & 0x3))       \
  200.      LOC = data_seg [(_addr_ - DATA_BOT) >> 2];                   \
  201.   else if (_addr_ >= stack_bot && _addr_ < STACK_TOP && !(_addr_ & 0x3))   \
  202.     LOC = stack_seg [(_addr_ - stack_bot) >> 2];               \
  203.    else if (_addr_ >= K_DATA_BOT && _addr_ < k_data_top && !(_addr_ & 0x3))\
  204.      LOC = k_data_seg [(_addr_ - K_DATA_BOT) >> 2];               \
  205.   else                                       \
  206.     LOC = bad_mem_read (_addr_, 0x3, (mem_word *)&LOC);}
  207.  
  208.  
  209. #define SET_MEM_INST(ADDR, INST)                       \
  210. {register mem_addr _addr_ = (mem_addr) (ADDR);                   \
  211.    text_modified = 1;                               \
  212.    if (_addr_ >= TEXT_BOT && _addr_ < text_top && !(_addr_ & 0x3))       \
  213.      text_seg [(_addr_ - TEXT_BOT) >> 2] = INST;               \
  214.    else if (_addr_ >= K_TEXT_BOT && _addr_ < k_text_top && !(_addr_ & 0x3))\
  215.      k_text_seg [(_addr_ - K_TEXT_BOT) >> 2] = INST;               \
  216.    else bad_text_write (_addr_, INST);}
  217.  
  218.  
  219. #define SET_MEM_BYTE(ADDR, VALUE)                       \
  220. {register mem_addr _addr_ = (mem_addr) (ADDR);                   \
  221.    data_modified = 1;                               \
  222.    if (_addr_ >= DATA_BOT && _addr_ < data_top)                   \
  223.      data_seg_b [_addr_ - DATA_BOT] = (unsigned char) (VALUE);           \
  224.    else if (_addr_ >= stack_bot && _addr_ < STACK_TOP)               \
  225.      stack_seg_b [_addr_ - stack_bot] = (unsigned char) (VALUE);       \
  226.    else if (_addr_ >= K_DATA_BOT && _addr_ < k_data_top)           \
  227.      k_data_seg_b [_addr_ - K_DATA_BOT] = (unsigned char) (VALUE);       \
  228.    else bad_mem_write (_addr_, VALUE, 0);}
  229.  
  230.  
  231. #define SET_MEM_HALF(ADDR, VALUE)                       \
  232. {register mem_addr _addr_ = (mem_addr) (ADDR);                   \
  233.    data_modified = 1;                               \
  234.    if (_addr_ >= DATA_BOT && _addr_ < data_top && !(_addr_ & 0x1))       \
  235.      data_seg_h [(_addr_ - DATA_BOT) >> 1] = (unsigned short) (VALUE);       \
  236.    else if (_addr_ >= stack_bot && _addr_ < STACK_TOP && !(_addr_ & 0x1))  \
  237.      stack_seg_h [(_addr_ - stack_bot) >> 1] = (unsigned short) (VALUE);   \
  238.    else if (_addr_ >= K_DATA_BOT && _addr_ < k_data_top && !(_addr_ & 0x1))\
  239.      k_data_seg_h [(_addr_ - K_DATA_BOT) >> 1] = (unsigned short) (VALUE); \
  240.    else bad_mem_write (_addr_, VALUE, 0x1);}
  241.  
  242.  
  243. #define SET_MEM_WORD(ADDR, VALUE)                       \
  244. {register mem_addr _addr_ = (mem_addr) (ADDR);                   \
  245.    data_modified = 1;                               \
  246.    if (_addr_ >= DATA_BOT && _addr_ < data_top && !(_addr_ & 0x3))       \
  247.      data_seg [(_addr_ - DATA_BOT) >> 2] = (mem_word) (VALUE);           \
  248.    else if (_addr_ >= stack_bot && _addr_ < STACK_TOP && !(_addr_ & 0x3))  \
  249.      stack_seg [(_addr_ - stack_bot) >> 2] = (mem_word) (VALUE);       \
  250.    else if (_addr_ >= K_DATA_BOT && _addr_ < k_data_top && !(_addr_ & 0x3))\
  251.      k_data_seg [(_addr_ - K_DATA_BOT) >> 2] = (mem_word) (VALUE);       \
  252.    else bad_mem_write (_addr_, VALUE, 0x3);}
  253.  
  254.  
  255.  
  256.  
  257. /* Exported functions: */
  258.  
  259. #ifdef __STDC__
  260. mem_word bad_mem_read (mem_addr addr, int mask, mem_word *dest);
  261. void bad_mem_write (mem_addr addr, mem_word value, int mask);
  262. instruction *bad_text_read (mem_addr addr);
  263. void bad_text_write (mem_addr addr, instruction *inst);
  264. void check_memory_mapped_IO (void);
  265. void expand_data (long int addl_bytes);
  266. void expand_k_data (long int addl_bytes);
  267. void expand_stack (long int addl_bytes);
  268. void make_memory (long int text_size, long int data_size, long int data_limit,
  269.     long int stack_size, long int stack_limit, long int k_text_size,
  270.     long int k_data_size, long int k_data_limit);
  271. void print_mem (mem_addr addr);
  272. #else
  273. mem_word bad_mem_read ();
  274. void bad_mem_write ();
  275. instruction *bad_text_read ();
  276. void bad_text_write ();
  277. void check_memory_mapped_IO ();
  278. void expand_data ();
  279. void expand_k_data ();
  280. void expand_stack ();
  281. void make_memory ();
  282. void print_mem ();
  283. #endif
  284.